package protocols

import (
	"github.com/quic-go/quic-go"
)

// ========================================
// 协议处理器抽象接口
// ========================================

// ProtocolHandler 协议处理器接口
// 所有协议（HTTP、TCP、SSH等）都必须实现此接口
type ProtocolHandler interface {
	// HandleRequest 处理来自服务端的请求
	// stream: QUIC流，用于双向通信
	// msg: 隧道消息，包含协议类型、请求ID、数据等
	HandleRequest(stream quic.Stream, msg *TunnelMessage) error

	// GetProtocolType 获取协议类型
	GetProtocolType() ProtocolType

	// Close 关闭处理器，释放资源
	Close() error

	// GetStats 获取协议统计信息
	GetStats() ProtocolStats
}

// ProtocolStats 协议统计信息
type ProtocolStats struct {
	TotalRequests   int64 // 总请求数
	ActiveRequests  int64 // 当前活跃请求数
	TotalBytesSent  int64 // 总发送字节数
	TotalBytesRecv  int64 // 总接收字节数
	SuccessCount    int64 // 成功次数
	ErrorCount      int64 // 错误次数
	AvgResponseTime int64 // 平均响应时间（毫秒）
}

// ProtocolType 协议类型
type ProtocolType uint8

const (
	ProtocolHTTP ProtocolType = 1 // HTTP协议
	ProtocolTCP  ProtocolType = 2 // TCP协议
	ProtocolSSH  ProtocolType = 3 // SSH协议（预留）
	ProtocolRDP  ProtocolType = 4 // RDP协议（预留）
	ProtocolUDP  ProtocolType = 5 // UDP协议（预留）
)

// String 返回协议类型的字符串表示
func (p ProtocolType) String() string {
	switch p {
	case ProtocolHTTP:
		return "HTTP"
	case ProtocolTCP:
		return "TCP"
	case ProtocolSSH:
		return "SSH"
	case ProtocolRDP:
		return "RDP"
	case ProtocolUDP:
		return "UDP"
	default:
		return "UNKNOWN"
	}
}

// Validate 验证协议类型是否有效
func (p ProtocolType) Validate() error {
	switch p {
	case ProtocolHTTP, ProtocolTCP, ProtocolSSH, ProtocolRDP, ProtocolUDP:
		return nil
	default:
		return &InvalidProtocolError{Type: uint8(p)}
	}
}

// InvalidProtocolError 无效的协议类型错误
type InvalidProtocolError struct {
	Type uint8
}

func (e *InvalidProtocolError) Error() string {
	return "invalid protocol type: " + string(rune(e.Type))
}

// TunnelMessage 隧道消息（需要从quic_protocol.go导入）
// 这里只是类型声明，实际定义在quic_protocol.go
type TunnelMessage struct {
	Version      uint32
	MessageType  uint8
	ProtocolType ProtocolType
	TunnelID     string
	RequestID    string
	ConnectionID string
	Body         []byte
	BodyLength   uint64
}

// ========================================
// 协议工厂接口
// ========================================

// ProtocolFactory 协议处理器工厂接口
type ProtocolFactory interface {
	// CreateHandler 创建协议处理器
	CreateHandler(tunnelID, targetHost, targetPort string) (ProtocolHandler, error)

	// SupportedProtocol 返回支持的协议类型
	SupportedProtocol() ProtocolType
}

// ProtocolRegistry 协议注册表
type ProtocolRegistry struct {
	factories map[ProtocolType]ProtocolFactory
}

// NewProtocolRegistry 创建协议注册表
func NewProtocolRegistry() *ProtocolRegistry {
	return &ProtocolRegistry{
		factories: make(map[ProtocolType]ProtocolFactory),
	}
}

// Register 注册协议工厂
func (r *ProtocolRegistry) Register(factory ProtocolFactory) {
	r.factories[factory.SupportedProtocol()] = factory
}

// CreateHandler 创建协议处理器
func (r *ProtocolRegistry) CreateHandler(protocolType ProtocolType, tunnelID, targetHost, targetPort string) (ProtocolHandler, error) {
	factory, exists := r.factories[protocolType]
	if !exists {
		return nil, &UnsupportedProtocolError{Type: protocolType}
	}
	return factory.CreateHandler(tunnelID, targetHost, targetPort)
}

// GetSupportedProtocols 获取所有支持的协议类型
func (r *ProtocolRegistry) GetSupportedProtocols() []ProtocolType {
	protocols := make([]ProtocolType, 0, len(r.factories))
	for pt := range r.factories {
		protocols = append(protocols, pt)
	}
	return protocols
}

// UnsupportedProtocolError 不支持的协议类型错误
type UnsupportedProtocolError struct {
	Type ProtocolType
}

func (e *UnsupportedProtocolError) Error() string {
	return "unsupported protocol type: " + e.Type.String()
}
